package com.imooc.controller;

import com.imooc.pojo.Users;
import com.imooc.pojo.vo.UsersVO;
import com.imooc.service.UserService;
import com.imooc.utils.IMOOCJSONResult;
import com.imooc.utils.JsonUtils;
import com.imooc.utils.MD5Utils;
import com.imooc.utils.RedisOperator;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseCookie;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import springfox.documentation.annotations.ApiIgnore;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.UUID;

//@Controller
@ApiIgnore  // Swagger2的显示中忽略该 Controller
@Controller
public class SSOController {

    @Autowired
    private UserService userService;

    @Autowired
    private RedisOperator redisOperator;

    public static final String REDIS_USER_TOKEN = "redis_user_token";

    private static final String REDIS_USER_TICKET = "redis_user_ticket";

    private static final String REDIS_TMP_TICKET = "redis_tmp_ticket";

    private static final String COOKIE_USER_TICKET = "cookie_user_ticket";


    /**
     * 用户进入某个系统，都需要先到CAS系统中判断是否有登陆过
     * 如果登录过，就生成一个临时票据，然后回跳到ReturnUrl页面中
     * 如果没有登录过，就会跳转到CAS系统的统一登录页面 login.html中
     */
    @GetMapping("/login")
    public String login(String returnUrl,
                        Model model,
                        HttpServletRequest request,
                        HttpServletResponse response){
        model.addAttribute("returnUrl",returnUrl);
        //1. 获取UserTicket门票，如果Cookie中能够获取到，证明用户登陆过，就签发一个一次性的临时票据
        String userTicket = getCookie(request,COOKIE_USER_TICKET);
        // 2. 判断用户是否登录过
        boolean isVerified = verifyUserTicket(userTicket);
        // 用户登录过，就不需要再进行登录操作了
        if(isVerified){
            String tmpTicket = createTmpTicket();
            return "redirect:"+returnUrl+"?tmpTicket="+tmpTicket;
        }
        // 用户从未登录过，第一次进入则跳转到CAS的统一登录页面
        return "login";
    }

    /**
     * 验证CAS全局用户门票 （判断用户是否有在CAS系统中登录过）
     * @param userTicket  cookie中获取到全局用户门票
     * @return
     */
    private boolean verifyUserTicket(String userTicket){
        if(StringUtils.isBlank(userTicket)){
            return false;
        }
        // 验证CAS门票是否有效
        String userId = redisOperator.get(REDIS_USER_TICKET+":"+userTicket);
        if(StringUtils.isBlank(userId)){
           return false;
        }
        // 验证门票对应的user会话是否存在
        String userRedis = redisOperator.get(REDIS_USER_TOKEN+":"+userId);
        if(StringUtils.isBlank(userRedis)){
            return false;
        }

        return true;
    }

    /**
     * CAS的统一登录接口
     *      目的： 1. 登录后创建用户的全局分布式会话  ==> uniqueToken
     *            2. 创建用户全局门票，用于表示用户在CAS端是否登录  ==> userTicket
     *            3. 创建用户临时票据，用于回跳回传(临时：有时效性)  ==> tmpTicket
     */
    @PostMapping("/doLogin")
    public String doLogin(String username,
                          String password,
                          String returnUrl,
                          Model model,
                          HttpServletRequest request,
                          HttpServletResponse response) throws Exception {

        model.addAttribute("returnUrl",returnUrl);

        // 0. 判断用户名和密码必须不为空
        if (StringUtils.isBlank(username) ||
                StringUtils.isBlank(password)) {
            model.addAttribute("errmsg","用户名或密码不能为空");
            return "login";
        }

        // 1. 实现登录
        Users userResult = userService.queryUserForLogin(username,
                MD5Utils.getMD5Str(password));

        if (userResult == null) {
            model.addAttribute("errmsg","用户名或密码不正确");
            return "login";
        }

        // 2. 登录成功,创建用户会话
        // 实现用户的Redis会话
        String uniqueToken = UUID.randomUUID().toString().trim();
        UsersVO usersVO = new UsersVO();
        BeanUtils.copyProperties(userResult,usersVO);
        usersVO.setUserUniqueToken(uniqueToken);
        // 存储用户会话到Redis中
        redisOperator.set(REDIS_USER_TOKEN+":"+userResult.getId(), JsonUtils.objectToJson(usersVO));

        // 3.生成 ticket门票，全局门票，代表用户在CAS端登录过
        String userTicket = UUID.randomUUID().toString().trim();

        // 3.1 用户全局门票，需要放入CAS端的Cookie中，下次用户从别的系统进入CAS系统，是从Cookie中获取到门票来进行检测
        setCookie(COOKIE_USER_TICKET,userTicket,response);

        // 4. userTicket 需要关联用户Id，并且放入到Redis中，代表这个用户已经登录了，可以在各个系统中进行浏览
        redisOperator.set(REDIS_USER_TICKET+":"+userTicket,userResult.getId());

        // 5. 生成临时票据，回跳到调用端网址，是由CAS端所签发的一个一次性的临时ticket
        // tmpTicket 也要存入到Redis中
        String tmpTicket = createTmpTicket();

        /**
         * UserTicket : 用于表示用户在CAS端的一个登录状态： 是否已经登录 （全局状态）
         * tmpTicket : 用于颁发给用户进行一次性的验证的票据，是具有时效性的
         * 举例：
         *  去动物园玩耍，大门口买了一张统一的门票 （这就是CAS系统的全局门票和用户全局会话）
         *  动物园中有一些小的景点，需要凭你的门票去领取一次性的票据，有了这个票据就可以去一些小景点游玩
         *  这边的小景点对应我们的一个个站点。
         *  当我们使用完这张临时票据后，需要进行销毁。
         */

        //return "login";
        //6.回跳到调用端网址
        return "redirect:"+returnUrl+"?tmpTicket="+tmpTicket;

    }

    @PostMapping("/verifyTmpTicket")
    @ResponseBody
    public IMOOCJSONResult verifyTmpTicket(String tmpTicket,
                                           HttpServletRequest request,
                                           HttpServletResponse response) throws Exception {
        // 使用一次性临时票据来验证用户是否登录，如果登录过，将用户会话信息返回给站点
        // 使用完毕后，需要销毁临时票据
        String tmpTicketValue = redisOperator.get(REDIS_TMP_TICKET+":"+tmpTicket);
        if(StringUtils.isBlank(tmpTicketValue)){
            return IMOOCJSONResult.errorUserTicket("用户票据异常");
        }
        // 0. 如果临时票据验证通过，则需要销毁该票据，并且需要拿到CAS端的cookie的全局userTicket，以此再获取到用户的全局会话
        if(!tmpTicketValue.equals(MD5Utils.getMD5Str(tmpTicket))){
            return IMOOCJSONResult.errorUserTicket("用户票据异常");
        }else{
            // 销毁临时票据
            redisOperator.del(REDIS_TMP_TICKET+":"+tmpTicket);
        }

        // 1.验证并且获取到用户的 UserTicket
        String userTicket = getCookie(request,COOKIE_USER_TICKET);
        String userId = redisOperator.get(REDIS_USER_TICKET+":"+userTicket);
        if(StringUtils.isBlank(userId)){
            return IMOOCJSONResult.errorUserTicket("用户票据异常");
        }
        // 2.验证门票对应的User会话是否存在
        String userRedis = redisOperator.get(REDIS_USER_TOKEN+":"+userId);
        if(StringUtils.isBlank(userRedis)){
            return IMOOCJSONResult.errorUserTicket("用户票据异常");
        }
        // 3.验证成功，返回OK，携带用户会话

        return IMOOCJSONResult.ok(JsonUtils.jsonToPojo(userRedis,UsersVO.class));
    }

    /**
     * 用户退出登录
     *      将Cookie和redis中的门票数据进行清除
     *      清除用户全局会话(redis中）
     * @param userId 用户Id
     */
    @PostMapping("/logout")
    @ResponseBody
    public IMOOCJSONResult logout(String userId,
                                  HttpServletRequest request,
                                  HttpServletResponse response){
        // 0.获取CAS中的用户全局门票
        String userTicket = getCookie(request,COOKIE_USER_TICKET);
        // 1.清除 userTicket票据 (redis和cookie中都需要清除）
        deleteCookie(COOKIE_USER_TICKET,response);
        redisOperator.del(REDIS_USER_TICKET+":"+userTicket);
        // 2.清除用户全局会话(分布式会话）
        redisOperator.del(REDIS_USER_TOKEN+":"+userId);

        return IMOOCJSONResult.ok();
    }

    /**
     * 创建临时票据
     * @return 临时票据
     */
    private String createTmpTicket(){
        String tmpTicket = UUID.randomUUID().toString().trim();
        try {
            redisOperator.set(REDIS_TMP_TICKET+":"+tmpTicket,MD5Utils.getMD5Str(tmpTicket),600);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return tmpTicket;
    }

    /**
     * 设置CAS系统的cookie
     */
    private void setCookie(String key,String val,HttpServletResponse response){
        /*ResponseCookie responseCookie = ResponseCookie.from(key,val).
                secure(true).
                domain("sso.com").
                path("/").
                sameSite("None").
                build();
        System.out.println(responseCookie.toString());
        response.setHeader(HttpHeaders.SET_COOKIE,responseCookie.toString());*/

        Cookie cookie = new Cookie(key,val);
        cookie.setDomain("sso.com");
        cookie.setPath("/");
        response.addCookie(cookie);
    }

    /**
     * 获取到cookie中的值
     */
    private String getCookie(HttpServletRequest request,String key){
        Cookie[] cookieList = request.getCookies();
        if(cookieList == null || StringUtils.isBlank(key)){
            return null;
        }
        String cookieValue = null;
        for (int i = 0 ; i < cookieList.length; i ++) {
            if (cookieList[i].getName().equals(key)) {
                cookieValue = cookieList[i].getValue();
                break;
            }
        }
        return cookieValue;
    }

    private void deleteCookie(String key,HttpServletResponse response){
        Cookie cookie = new Cookie(key,null);
        cookie.setDomain("sso.com");
        cookie.setPath("/");
        cookie.setMaxAge(-1);
        response.addCookie(cookie);
    }

}
